package com.kaifamiao.jdbc.helper;

import java.math.BigInteger;
import java.nio.charset.Charset;
import java.nio.charset.StandardCharsets;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.Random;
import java.util.UUID;

public class StringHelper {

    public static final String uuid() {
        // 随机产生一个 UUID 实例
        UUID uuid = UUID.randomUUID();
        // 获得 UUID 实例中的字符串 ( 是一个包含了 4 个 `-` 的36位长度的字符串 )
        String uuidString = uuid.toString() ;
        System.out.println( uuidString );
        // 剔除 字符串中的 - 字符 (用空串替换)
        uuidString = uuidString.replace( "-", "" );
        // 将字符串全部转换成大写字母
        uuidString = uuidString.toUpperCase() ;
        return uuidString ;
    }

    /**
     * 根据指定的算法名称获取对应的 "信息摘要" 对象
     * @param algorithmName 指定的算法名称
     * @return
     */
    public static final MessageDigest digest(String algorithmName){
        try {
            MessageDigest digest = MessageDigest.getInstance(algorithmName);
            return digest ;
        } catch (NoSuchAlgorithmException e) {
            throw new RuntimeException( "不支持[ " + algorithmName + " ]算法" , e );
        }
    }

    /**
     * 使用 SHA-1 加密算法对 字符串进行加密 ( 如果被加密的字符串中含有中文，则使用 UTF-8 编码处理 )
     * @param source 需要被加密的字符串
     * @return 返回采用 SHA-1 加密算法加密后的 新字符串
     */
    public static final String encrypt( String source ) {
        return encrypt(source , MessageDigestType.SHA1 , StandardCharsets.UTF_8) ;
    }

    /**
     * 使用指定的 加密算法 对字符串进行加密处理
     * @param source 需要加密的字符串
     * @param type 需要采用的加密算法
     * @param cs 字符编码对象(用来将字符串转换为字节序列) ，如果参数为 null 则表示采用默认编码
     * @return 返回采用指定加密算法加密后的字符串
     */
    public static final String encrypt( String source ,MessageDigestType type , Charset cs ){
        if( source == null || source.isBlank() ){
            throw new RuntimeException( "被加密的字符串不能为空" );
        }
        // 获得指定 算法名称 对应的 信息摘要对象
        MessageDigest md = digest( type.getAlgorithmName() ) ;
        // 使用指定的字符编码将字符串转换为字节序列
        byte[] bytes = null ;
        if( cs == null ) {
            bytes = source.getBytes();
        } else {
            bytes = source.getBytes( cs ) ;
        }
        // 使用 信息摘要对象 对字节序列 进行加密处理
        md.update( bytes );
        // 获取加密后的字节序列
        byte[] mdBytes = md.digest();
        // 采用 big-endian 将 mdBytes 中的字节转换成一个非负整数 ( 1 表示非负数 )
        BigInteger bigInt = new BigInteger( 1 , mdBytes );
        // 将 非负整数 转换成 16进制形式字符串
        return bigInt.toString(16) ;
    }

    private static final String SYMBOL = "0123456789abcdefghijklmnopqrstuvwxyz" ;

    public static final String random( final int length ){
        StringBuilder sb = new StringBuilder() ;
        Random random = new Random();
        final int bound = SYMBOL.length();
        for( int i = 0 ; i < length ; i++ ) {
            int index = random.nextInt(bound);
            char ch = SYMBOL.charAt(index);
            sb.append( ch );
        }
        return sb.toString() ;
    }

    public static void main(String[] args) {
        System.out.println( uuid() );
        System.out.println( digest("md5"));
        System.out.println( digest("sha-1"));
        System.out.println( digest("sha-512"));
        System.out.println( encrypt( "bugaosuni" ) );
        System.out.println( encrypt( "bugaosuni" , MessageDigestType.SHA256, StandardCharsets.UTF_8) );
        System.out.println( random( 8 ) );
    }
}
